package homeword;

/**
 * 设计模式，单例模式
 */
public class Test03 {
    public static void main(String[] args) {
        /**
         * 测试饥饿式单例模式
         */
        StarvSingleton instance = StarvSingleton.getInstance();
        StarvSingleton instance2 = StarvSingleton.getInstance();
        System.out.println(instance==instance2);
        System.out.println("----------------------------------");
        /**
         * 测试懒惰单例模式
         */
        LazySingleton instance3 = LazySingleton.getInstance();
        LazySingleton instance4 = LazySingleton.getInstance();
        System.out.println(instance3==instance4);
    }

}
/**
 * 01.饿汉式单例模式
 * 解释：之所以是饿汉式，就是因为还没用到呢,就算没用到getInstance，只要类加载了（比如调用了里面的形态属性），
 *  就直接给我把对象实例都给创建了，会存在资源浪费的情况
 * 特点：
 *      1. 私有化构造器
 *      2. 新建实例也是私有化的静态的（之所以是静态的是因为外面创建不了实例啦，无法new对象，所以要静态）
 *      3. 暴漏一个静态方法给外界拿到创建的实例（因为静态成员也是整个类共享的，所以就用静态的，
 *      之所以暴漏是因为外界要用本实例）
 * 测试：
 *      1. 测试对象引用地址是不是同一个，也就是==或者equals即可
 */
class StarvSingleton {
    private static StarvSingleton instance = new StarvSingleton();
    private StarvSingleton(){
        System.out.println("StarvSingleton被创建了");
    }
    public static StarvSingleton getInstance(){
        return instance;
    }
}
/**
 * 02,不饥饿版本的单例模式，即懒汉式案例模式，懒惰单例模式
 * 特点：
 *      1. 类加载的时候不创建实例，静态的instance那个只是引用
 *      2. 符合单例模式
 *      3. 用上的时候才创建实例（就是getInstance的时候我才创建）
 *      4. 构造器私有化（防止随意new对象）
 */
class LazySingleton {
    //懒汉式，这里不创建对象，只是引用
    private static LazySingleton instance;
    private LazySingleton(){
        System.out.println("LazySingleton被创建了");
    }
    //只有调用了本方法才会创建实例，如果已经创建过了，就会返回上一个实例，会产生线程安全问题
    public static LazySingleton getInstance(){
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}
